home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / fax / src / port / generic / GCC-PATCH next >
Text File  |  1994-08-01  |  11KB  |  321 lines
  1. Fri Apr  9 20:03:38 1993  Jim Wilson  (wilson@wookumz.gnu.ai.mit.edu)
  2.  
  3.     * c-typeck.c (free_tree_list): New variable.
  4.     (digest_init): Set free_tree_list.
  5.     (process_init_constructor): Use add_double to do arithmetic with
  6.     double integers instead of using fold/build to to arithmetic in
  7.     type of array index.  Use free_tree_list when available instead of
  8.     generating a new tree_list.
  9.  
  10. *** c-typeck.c.orig    Thu Nov 26 12:30:00 1992
  11. --- c-typeck.c    Sat Apr 17 22:12:17 1993
  12. *************** pedwarn_init (format, local, ofwhat)
  13. *** 4521,4526 ****
  14. --- 4521,4540 ----
  15.     pedwarn (format, buffer);
  16.   }
  17.   
  18. + /* Keep a pointer to the last free TREE_LIST node as we digest an initializer,
  19. +    so that we can reuse it.  This is set in digest_init, and used in
  20. +    process_init_constructor.
  21. + 
  22. +    We will never keep more than one free TREE_LIST node here.  This is for
  23. +    two main reasons.  First, we take elements off the old list and add them
  24. +    to the new list one at a time, thus there should never be more than
  25. +    one free TREE_LIST at a time, and thus even if there is, we will never
  26. +    need more than one.  Secondly, to avoid dangling pointers to freed obstacks,
  27. +    we want to always ensure that we have either a pointer to a valid TREE_LIST
  28. +    within the current initializer, or else a pointer to null.  */
  29. + 
  30. + static tree free_tree_list = NULL_TREE;
  31. + 
  32.   /* Digest the parser output INIT as an initializer for type TYPE.
  33.      Return a C expression of type TYPE to represent the initial value.
  34.   
  35. *************** digest_init (type, init, tail, require_c
  36. *** 4554,4566 ****
  37.     tree inside_init = init;
  38.   
  39.     /* By default, assume we use one element from a list.
  40. !      We correct this later in the sole case where it is not true.  */
  41.   
  42.     if (tail)
  43.       {
  44.         old_tail_contents = *tail;
  45.         *tail = TREE_CHAIN (*tail);
  46.       }
  47.   
  48.     if (init == error_mark_node)
  49.       return init;
  50. --- 4568,4588 ----
  51.     tree inside_init = init;
  52.   
  53.     /* By default, assume we use one element from a list.
  54. !      We correct this later in the cases where it is not true.
  55. ! 
  56. !      Thus, we update TAIL now to point to the next element, and save the
  57. !      old value in OLD_TAIL_CONTENTS.  If we didn't actually use the first
  58. !      element, then we will reset TAIL before proceeding.  FREE_TREE_LIST
  59. !      is handled similarly.  */
  60.   
  61.     if (tail)
  62.       {
  63.         old_tail_contents = *tail;
  64.         *tail = TREE_CHAIN (*tail);
  65. +       free_tree_list = old_tail_contents;
  66.       }
  67. +   else
  68. +     free_tree_list = 0;
  69.   
  70.     if (init == error_mark_node)
  71.       return init;
  72. *************** digest_init (type, init, tail, require_c
  73. *** 4737,4742 ****
  74. --- 4759,4765 ----
  75.         else if (tail != 0)
  76.       {
  77.         *tail = old_tail_contents;
  78. +       free_tree_list = NULL_TREE;
  79.         result = process_init_constructor (type, NULL_TREE, tail,
  80.                            require_constant,
  81.                            constructor_constant, ofwhat);
  82. *************** digest_init (type, init, tail, require_c
  83. *** 4833,4838 ****
  84. --- 4856,4862 ----
  85.         else if (tail != 0)
  86.       {
  87.         *tail = old_tail_contents;
  88. +       free_tree_list = NULL_TREE;
  89.         return process_init_constructor (type, NULL_TREE, tail,
  90.                          constructor_constant,
  91.                          constructor_constant, ofwhat);
  92. *************** process_init_constructor (type, init, el
  93. *** 4917,4954 ****
  94.   
  95.     if (TREE_CODE (type) == ARRAY_TYPE)
  96.       {
  97. !       tree min_index, max_index, current_index, members_index;
  98. !       tree bound_type;
  99. !       tree one;
  100.         /* These are non-zero only within a range initializer.  */
  101.         tree start_index = 0, end_index = 0;
  102.         /* Within a range, this is the value for the elts in the range.  */
  103.         tree range_val = 0;
  104.   
  105.         /* If we have array bounds, set our bounds from that.  Otherwise,
  106. !      we have a lower bound of zero and an unknown upper bound.  Also
  107. !      set the type of the bounds; use "int" as default.  */
  108.         if (TYPE_DOMAIN (type))
  109.       {
  110. !       min_index = members_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
  111.         max_index = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
  112. -       bound_type = TREE_TYPE (min_index);
  113.       }
  114.         else
  115.       {
  116. !       min_index = members_index = integer_zero_node;
  117.         max_index = 0;
  118. -       bound_type = integer_type_node;
  119.       }
  120.   
  121. !       one = convert (bound_type, integer_one_node);
  122.   
  123.         /* Don't leave the loop based on index if the next item has an explicit
  124.        index value that will override it. */
  125.   
  126. !       for (current_index = min_index; tail != 0 || end_index;
  127. !        current_index = fold (build (PLUS_EXPR, bound_type,
  128. !                     current_index, one)))
  129.       {
  130.         register tree next1 = 0;
  131.   
  132. --- 4941,4987 ----
  133.   
  134.     if (TREE_CODE (type) == ARRAY_TYPE)
  135.       {
  136. !       tree min_index, max_index;
  137.         /* These are non-zero only within a range initializer.  */
  138.         tree start_index = 0, end_index = 0;
  139.         /* Within a range, this is the value for the elts in the range.  */
  140.         tree range_val = 0;
  141. +       /* Do arithmetic using double integers, but don't use fold/build,
  142. +      because these allocate a new tree object everytime they are called,
  143. +      thus resulting in gcc using too much memory for large
  144. +      initializers.  */
  145. +       union tree_node current_index_node, members_index_node;
  146. +       tree current_index = ¤t_index_node;
  147. +       tree members_index = &members_index_node;
  148. +       TREE_TYPE (current_index) = integer_type_node;
  149. +       TREE_TYPE (members_index) = integer_type_node;
  150.   
  151.         /* If we have array bounds, set our bounds from that.  Otherwise,
  152. !      we have a lower bound of zero and an unknown upper bound.  */
  153.         if (TYPE_DOMAIN (type))
  154.       {
  155. !       min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
  156.         max_index = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
  157.       }
  158.         else
  159.       {
  160. !       min_index = integer_zero_node;
  161.         max_index = 0;
  162.       }
  163.   
  164. !       TREE_INT_CST_LOW (members_index) = TREE_INT_CST_LOW (min_index);
  165. !       TREE_INT_CST_HIGH (members_index) = TREE_INT_CST_HIGH (min_index);
  166.   
  167.         /* Don't leave the loop based on index if the next item has an explicit
  168.        index value that will override it. */
  169.   
  170. !       for (TREE_INT_CST_LOW (current_index) = TREE_INT_CST_LOW (min_index),
  171. !        TREE_INT_CST_HIGH (current_index) = TREE_INT_CST_HIGH (min_index);
  172. !        tail != 0 || end_index;
  173. !        add_double (TREE_INT_CST_LOW (current_index),
  174. !                TREE_INT_CST_HIGH (current_index), 1, 0,
  175. !                &TREE_INT_CST_LOW (current_index),
  176. !                &TREE_INT_CST_HIGH (current_index)))
  177.       {
  178.         register tree next1 = 0;
  179.   
  180. *************** process_init_constructor (type, init, el
  181. *** 5095,5114 ****
  182.            Make the list longer if necessary.  */
  183.         while (! tree_int_cst_lt (current_index, members_index))
  184.           {
  185. !           members = tree_cons (NULL_TREE, NULL_TREE, members);
  186. !           members_index = fold (build (PLUS_EXPR, bound_type,
  187. !                        members_index, one));
  188.           }
  189.   
  190.         {
  191.           tree temp;
  192. !         tree idx;
  193.   
  194.           temp = members;
  195. !         for (idx = fold (build (MINUS_EXPR, bound_type,
  196. !                     members_index, one));
  197.            tree_int_cst_lt (current_index, idx);
  198. !          idx = fold (build (MINUS_EXPR, bound_type, idx, one)))
  199.             temp = TREE_CHAIN (temp);
  200.           TREE_VALUE (temp) = next1;
  201.         }
  202. --- 5128,5165 ----
  203.            Make the list longer if necessary.  */
  204.         while (! tree_int_cst_lt (current_index, members_index))
  205.           {
  206. !           if (free_tree_list)
  207. !         {
  208. !           TREE_CHAIN (free_tree_list) = members;
  209. !           TREE_PURPOSE (free_tree_list) = NULL_TREE;
  210. !           TREE_VALUE (free_tree_list) = NULL_TREE;
  211. !           members = free_tree_list;
  212. !           free_tree_list = NULL_TREE;
  213. !         }
  214. !           else
  215. !         members = tree_cons (NULL_TREE, NULL_TREE, members);
  216. !           add_double (TREE_INT_CST_LOW (members_index),
  217. !               TREE_INT_CST_HIGH (members_index), 1, 0,
  218. !               &TREE_INT_CST_LOW (members_index),
  219. !               &TREE_INT_CST_HIGH (members_index));
  220.           }
  221.   
  222.         {
  223.           tree temp;
  224. !         union tree_node idx_node;
  225. !         tree idx = &idx_node;
  226. !         TREE_TYPE (idx) = integer_type_node;
  227.   
  228.           temp = members;
  229. !         for (add_double (TREE_INT_CST_LOW (members_index),
  230. !                  TREE_INT_CST_HIGH (members_index), -1, -1,
  231. !                  &TREE_INT_CST_LOW (idx),
  232. !                  &TREE_INT_CST_HIGH (idx));
  233.            tree_int_cst_lt (current_index, idx);
  234. !          add_double (TREE_INT_CST_LOW (idx),
  235. !                  TREE_INT_CST_HIGH (idx), -1, -1,
  236. !                  &TREE_INT_CST_LOW (idx),
  237. !                  &TREE_INT_CST_HIGH (idx)))
  238.             temp = TREE_CHAIN (temp);
  239.           TREE_VALUE (temp) = next1;
  240.         }
  241. *************** process_init_constructor (type, init, el
  242. *** 5196,5202 ****
  243.            Make the list longer if necessary.  */
  244.         while (i >= members_length)
  245.           {
  246. !           members = tree_cons (NULL_TREE, NULL_TREE, members);
  247.             members_length++;
  248.           }
  249.         {
  250. --- 5247,5262 ----
  251.            Make the list longer if necessary.  */
  252.         while (i >= members_length)
  253.           {
  254. !           if (free_tree_list)
  255. !         {
  256. !           TREE_CHAIN (free_tree_list) = members;
  257. !           TREE_PURPOSE (free_tree_list) = NULL_TREE;
  258. !           TREE_VALUE (free_tree_list) = NULL_TREE;
  259. !           members = free_tree_list;
  260. !           free_tree_list = NULL_TREE;
  261. !         }
  262. !           else
  263. !         members = tree_cons (NULL_TREE, NULL_TREE, members);
  264.             members_length++;
  265.           }
  266.         {
  267. *************** process_init_constructor (type, init, el
  268. *** 5284,5291 ****
  269.         else if (!TREE_CONSTANT (next1))
  270.       allconstant = 0;
  271.         else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
  272. !     allsimple = 0;
  273. !       members = tree_cons (field, next1, members);
  274.       }
  275.   
  276.     /* If arguments were specified as a list, just remove the ones we used.  */
  277. --- 5344,5360 ----
  278.         else if (!TREE_CONSTANT (next1))
  279.       allconstant = 0;
  280.         else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
  281. !     allsimple = 0; 
  282. !      if (free_tree_list)
  283. !     {
  284. !       TREE_CHAIN (free_tree_list) = members;
  285. !       TREE_PURPOSE (free_tree_list) = field;
  286. !       TREE_VALUE (free_tree_list) = next1;
  287. !       members = free_tree_list;
  288. !       free_tree_list = NULL_TREE;
  289. !     }
  290. !       else
  291. !     members = tree_cons (field, next1, members);
  292.       }
  293.   
  294.     /* If arguments were specified as a list, just remove the ones we used.  */
  295. *************** process_init_constructor (type, init, el
  296. *** 5316,5322 ****
  297.     if (erroneous)
  298.       return error_mark_node;
  299.   
  300. !   result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
  301.     if (allconstant) TREE_CONSTANT (result) = 1;
  302.     if (allconstant && allsimple) TREE_STATIC (result) = 1;
  303.     return result;
  304. --- 5385,5400 ----
  305.     if (erroneous)
  306.       return error_mark_node;
  307.   
  308. !   if (elts)
  309. !     result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
  310. !   else
  311. !     {
  312. !       result = init;
  313. !       CONSTRUCTOR_ELTS (result) = nreverse (members);
  314. !       TREE_TYPE (result) = type;
  315. !       TREE_CONSTANT (result) = 0;
  316. !       TREE_STATIC (result) = 0;
  317. !     }
  318.     if (allconstant) TREE_CONSTANT (result) = 1;
  319.     if (allconstant && allsimple) TREE_STATIC (result) = 1;
  320.     return result;
  321.